Error identification in executed code

ABSTRACT

The present disclosure includes apparatuses, methods, and systems for error identification on executed code. An embodiment includes memory and circuitry configured to read data stored in a secure array of the memory, identify a different memory having an error correcting code (ECC) corresponding to the read data of the memory, execute an integrity check to compare the ECC to the read data of the memory; and take an action in response to the comparison of the read data of the memory and the ECC, wherein the comparison indicates that the ECC identified an error in the read data of the memory.

TECHNICAL FIELD

The present disclosure relates generally to semiconductor memory andmethods, and more particularly, to identify error in executed code.

BACKGROUND

Memory devices are typically provided as internal, semiconductor,integrated circuits and/or external removable devices in computers orother electronic devices. There are many different types of memoryincluding volatile and non-volatile memory. Volatile memory can requirepower to maintain its data and can include random-access memory (RAM),dynamic random access memory (DRAM), and synchronous dynamic randomaccess memory (SDRAM), among others. Non-volatile memory can providepersistent data by retaining stored data when not powered and caninclude NAND flash memory, NOR flash memory, read only memory (ROM), andresistance variable memory such as phase change random access memory(PCRAM), resistive random access memory (RRAM), and magnetic randomaccess memory (MRAM), among others.

Memory devices can be combined together to form a solid state drive(SSD), an embedded MultiMediaCard (e.g., MMC), and/or a universal flashstorage (UFS) device. An SSD, e.MMC, and/or UFS device can includenon-volatile memory (e.g., NAND flash memory and/or NOR flash memory),and/or can include volatile memory (e.g., DRAM and/or SDRAM), amongvarious other types of non-volatile and volatile memory. Non-volatilememory may be used in a wide range of electronic applications such aspersonal computers, portable memory sticks, digital cameras, cellulartelephones, portable music players such as MP3 players, movie players,among others.

Flash memory devices can include memory cells storing data in a chargestorage structure such as a floating gate, for instance. Flash memorydevices typically use a one-transistor memory cell that allows for highmemory densities, high reliability, and low power consumption.Resistance variable memory devices can include resistive memory cellsthat can store data based on the resistance state of a storage element(e.g., a resistive memory element having a variable resistance).

Memory cells can be arranged into arrays, and memory cells in an arrayarchitecture can be programmed to a target (e.g., desired) state. Forinstance, electric charge can be placed on or removed from the chargestorage structure (e.g., floating gate) of a flash memory cell toprogram the cell to a particular data state. The stored charge on thecharge storage structure of the cell can indicate a threshold voltage(Vt) of the cell. A state of a flash memory cell can be determined bysensing the stored charge on the charge storage structure (e.g., the Vt)of the cell.

Errors introduced into code and threats imposed of stored code canaffect the operation of a memory device and/or the data stored in thememory cells of the memory device. Errors may be introduced by noise,and/or during transmission. Threats can include, for example, threatsfrom hackers or other malicious users, including intentional errorintroduction, man-in-the-middle (MITM) attacks, among others. Suchthreats can cause significant financial loss, and/or can presentsignificant safety and/or security issues.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates a diagram of a portion of a memory array having anumber of physical blocks in accordance with an embodiment of thepresent disclosure.

FIG. 2A illustrates an example of a pair of registers used to define asecure memory array in accordance with an embodiment of the presentdisclosure.

FIG. 2B illustrates a diagram of a portion of a memory array thatincludes a secure memory array defined in accordance with an embodimentof the present disclosure.

FIG. 3 is a block diagram of a computing system including a host and anapparatus in the form of a memory device in accordance with anembodiment of the present disclosure.

FIG. 4 illustrates example block diagram of an example system includinga host controller and an apparatus in accordance with an embodiment ofthe present disclosure.

FIG. 5 illustrates an example flow diagram for error identification inexecuted code in accordance with embodiments of the present disclosure.

FIG. 6 is a block diagram of an example system including a host and amemory device in accordance with an embodiment of the presentdisclosure.

FIG. 7 is a block diagram of an example process to determine a number ofparameters in accordance with an embodiment of the present disclosure.

FIG. 8 is a block diagram of an example process to determine a number ofparameters in accordance with an embodiment of the present disclosure.

FIG. 9 is a block diagram of an example process to verify a certificatein accordance with an embodiment of the present disclosure.

FIG. 10 is a block diagram of an example process to verify a signaturein accordance with an embodiment of the present disclosure.

FIG. 11 is a block diagram of an example memory device in accordancewith an embodiment of the present disclosure.

DETAILED DESCRIPTION

The present disclosure includes apparatuses, methods, and systems forerror identification in executed code. Error correction operations canbe performed on a host computing system and/or on a memory device. Anembodiment includes a memory, and circuitry configured to identify errorin executed code (e.g., read data) by comparing data read by the memorydevice to error correcting code (ECC) read by a different memory device.Comparing the read data of the memory device and the ECC of thedifferent memory device to determine if an error exists in the readdata.

Memory devices may be used to store data in a computing system and cantransfer such data between a host associated with the computing system.The data stored in a memory device may be code for routines important tothe operation of the of the host. For example, the host device may be avehicle and the routine may be an operation of the powertrain or thevehicle. Memory devices can be utilized as non-volatile memory for awide range of electronic applications.

A host can be communicatively coupled to multiple memory devices. In oneexample, a memory device may include data stored in a secure array ofthe memory device. The memory device may include circuitry to identify adifferent memory device having error correcting code (ECC) whichcorresponds to the data read by the memory device. The circuitry can beconfigured to execute an integrity check. An integrity check refers to acomparison of error corrected data to read data. For example, thecircuitry can be configured execute an integrity check to compare theECC to the read data of the memory device and take an action in responseto the comparison of the read data and the ECC. When the ECC indicates acorrection, the data read by the memory device may include a similarerror, and corrective actions may be taken to rectify the error.

Error (e.g., faults) may be introduced into data (e.g., the data storedin the memory cells) stored by a memory device in multiple ways. Errorcan be unintentionally introduced into code by noise and/or impairmentsduring transmission. In some instances, error can be inadvertentlyintroduced to the data stored in the memory causing changes to theoperation of the memory. Error may also be introduced to data stored bymemory intentionally through threats. For example, a hacker or othermalicious user may introduce error to attempt to perform activities(e.g., attacks), such as, for instance, a man-in-the-middle (MITM)attack, to make unauthorized changes to the operation of the memory,and/or to the data stored therein, for malicious purposes. Anotherexample of a threat and/or a consequence to error introduced to datastored by the memory, is a hacker or other malicious user can attempt toskip a portion of a command (e.g., a portion of executable code)referred herein as a routine, written as a check and/or as a securityprotocol to authenticate the command.

During such an attack and/or error, the routine is skipped and/oraltered, but the host may receive an indication that the routine wasexecuted. Said differently, a hacker and/or an error may falsify thecommand and cause an indication to be received by the host that theroutine was executed. Important routines written to check theauthenticity of a command (authenticate a component, authenticate asoftware version and/or update, user identity, etc.) may be designed toexecute during the start-up (e.g., boot) of the memory device. A hackerand/or an introduced error may change (e.g., mask) an external input totrigger conditions which may skip the routine written to validate theauthenticity of the command. One example of such routine may be aportion of executable code written to check the authenticity of paymentprior to execution of a software service (e.g., issuance of currencyfrom an automatic teller machine and/or transfer of data, execution ofsoftware, etc.). Other examples may include routines to validate asoftware license to authenticate that the software is genuine prior toexecution (computer systems updates, installation of software, etc.),important operation routine for the host device (e.g., start-upoperations, powertrain operations, etc.), and/or a routine to check thegenuineness of a system component and the configuration of the systemcomponent (e.g., process plant control, automotive components).

The detection and correction of error can be challenging because thecorrection of detected error can produce additional (e.g., new) errors.This may cause an unreliability in the resulting architecture of thecode (e.g., the routine) and can affect the operation of the memory andthe code stored in the memory. Many memory devices employ error checkingtechniques such as ECC which detect bit errors in data. The ECC can beassociated with groups of cells, e.g., memory blocks, memory segments,or memory sectors, and can rescue read failures by detecting andpossibly correcting bit errors. Examples, of ECC codes include, Hammingcodes, Reed-Solomon (RS) codes, Bose-Chaudhuri-Hochquenghem (BCH) codes,circular redundancy check (CRC) codes, Golay codes, Reed-Muller codes,Goppa codes, and Denniston codes, among others. In some approaches,these and other error checking techniques are performed on the memorydevice by a controller including circuitry that is coupled to the memorydevice. As mentioned, the ECC may inadvertently introduce new errors toimportant routines (e.g., commands), when the errors are identified andcorrected.

As such, in order to ensure that errors indicated by ECC are identifiedbut that new errors are not introduced when the identified errors arecorrected, an alert may be generated when such errors are detected. Ahost may be associated with multiple memory devices to detect theseerrors. For example, a host device may include a host controller whichis communicatively coupled to multiple memory devices (e.g., an ECCmemory device and a memory device absent ECC). The multiple memorydevices may be respectively provisioned with data (e.g., commands and/orroutines) and/or ECC corresponding to the data.

In some examples, the ECC and corresponding routines may be securelyprovisioned onto the memory devices during a manufacturing step and/orsecurely validated using a public/private key exchanged (furtherdiscussed herein). The ECC memory device including the ECC and a memorydevice including corresponding data (e.g., the routine) may be read inparallel by the respective memory devices. The ECC and the data executedmay be compared by the host device and/or a controller associated withthe host device. When an error is identified by the ECC running on amemory device having ECC, the data executed by the data memory devicecan be identified as including a potential error. Said differently,because the data in the memory device corresponds to the ECC in anothermemory device, an error identified by the ECC indicates an error in thedata of the memory device. In this instance, to avoid inadvertent errorintroduced by implementing an automatic correction, an action can betaken to alert the host and/or the controller that an error in the dataof the memory device has been identified. At that time, multipledecisions can be made as to how to correct the error without alteringthe architecture of important routines.

Embodiments of the present disclosure can utilize cryptographicprimitive solutions (e.g., the ECC and or a calculated digest) for errordetection in important routines by incorporating a comparison of ECC anddata executed in parallel by different memory devices communicativelycoupled to the host device. Such solutions can identify errorinadvertently and/or intentionally introduced to the code. This canprevent poor operation of important routines written to avoid financialloss, security protocols, and/or provide safety checks for operations ofthe host device. Further, when an error is identified, the introductionof new errors can be avoided by refraining from an automatic correction.Instead an action (e.g., an alert, alarm, and/or abortion of theroutine) can be determined by the host and/or a memory device associatedwith the host.

As used herein, “a”, “an”, or “a number of” can refer to one or more ofsomething, and “a plurality of” can refer to two or more such things.For example, a memory device can refer to one or more memory devices,and a plurality of memory devices can refer to two or more memorydevices. Additionally, the designators “M”, “P”, “R”, “B”, “S”, and “N”,as used herein, particularly with respect to reference numerals in thedrawings, indicates that a number of the particular feature sodesignated can be included with a number of embodiments of the presentdisclosure. The number may be the same or different betweendesignations.

The figures herein follow a numbering convention in which the firstdigit or digits correspond to the drawing figure number and theremaining digits identify an element or component in the drawing.Similar elements or components between different figures may beidentified by the use of similar digits. For example, 101 may referenceelement “01” in FIG. 1, and a similar element may be referenced as 201in FIG. 2.

FIG. 1 illustrates a diagram of a portion of a memory array 101 having anumber of physical blocks in accordance with an embodiment of thepresent disclosure. Memory array 101 can be, for example, a flash memoryarray such as a NAND flash memory array. As an additional example,memory array 101 can be a resistance variable memory array such as aPCRAM, RRAM, MMRAM, or spin torque transfer (STT) array, among others.However, embodiments of the present disclosure are not limited to aparticular type of memory array. Further, memory array 101 (e.g., asubset of array 101, or the whole array 201) can be a secure memoryarray, as will be further described herein. Further, although not shownin FIG. 1, memory array 101 can be located on a particular semiconductordie along with various peripheral circuitry associated with theoperation thereof.

As shown in FIG. 1, memory array 101 has a number of physical blocks107-0 (BLOCK 0), 107-1 (BLOCK 1), . . . , 107-B (BLOCK B) of memorycells. The memory cells can be single level cells and/or multilevelcells such as, for instance, two level cells, triple level cells (TLCs)or quadruple level cells (QLCs). As an example, the number of physicalblocks in memory array 101 may be 128 blocks, 512 blocks, or 1,024blocks, but embodiments are not limited to a particular power of two orto any particular number of physical blocks in memory array 101.

A number of physical blocks of memory cells (e.g., blocks 107-0, 107-1,. . . , 107-B) can be included in a plane of memory cells, and a numberof planes of memory cells can be included on a die. For instance, in theexample shown in FIG. 1, each physical block 107-0, 107-1, . . . , 107-Bcan be part of a single die. That is, the portion of memory array 101illustrated in FIG. 1 can be a die of memory cells.

As shown in FIG. 1, each physical block 107-0, 107-1, . . . , 107-Bincludes a number of physical rows (e.g., 103-0, 103-1, . . . , 103-R)of memory cells coupled to access lines (e.g., word lines). The numberof rows (e.g., word lines) in each physical block can be 32, butembodiments are not limited to a particular number of rows 103-0, 103-1,. . . , 103-R per physical block. Further, although not shown in FIG. 1,the memory cells can be coupled to columns of sense lines (e.g., datalines and/or digit lines).

As one of ordinary skill in the art will appreciate, each row 103-0,103-1, . . . , 103-R can include a number of pages of memory cells(e.g., physical pages). A physical page refers to a unit of programmingand/or sensing (e.g., a number of memory cells that are programmedand/or sensed together as a functional group). In the embodiment shownin FIG. 1, each row 103-0, 103-1, . . . , 103-R comprises one physicalpage of memory cells. However, embodiments of the present disclosure arenot so limited. For instance, in an embodiment, each row can comprisemultiple physical pages of memory cells (e.g., one or more even pages ofmemory cells coupled to even-numbered data lines, and one or more oddpages of memory cells coupled to odd numbered data lines). Additionally,for embodiments including multilevel cells, a physical page of memorycells can store multiple pages (e.g., logical pages) of data (e.g., anupper page of data and a lower page of data, with each cell in aphysical page storing one or more bits towards an upper page of data andone or more bits towards a lower page of data).

As shown in FIG. 1, a page of memory cells can comprise a number ofphysical sectors 105-0, 105-1, . . . , 105-S (e.g., subsets of memorycells). Each physical sector 105-0, 105-1, . . . , 105-S of cells canstore a number of logical sectors of data. Additionally, each logicalsector of data can correspond to a portion of a particular page of data.As an example, a first logical sector of data stored in a particularphysical sector can correspond to a logical sector corresponding to afirst page of data, and a second logical sector of data stored in theparticular physical sector can correspond to a second page of data. Eachphysical sector 105-0, 105-1, . . . , 105-S, can store system and/oruser data, and/or can include overhead data, such as error correctioncode (ECC) data, logical block address (LBA) data, and metadata.

Logical block addressing is a scheme that can be used by a host foridentifying a logical sector of data. For example, each logical sectorcan correspond to a unique logical block address (LBA). Additionally, anLBA may also correspond (e.g., dynamically map) to a physical address,such as a physical block address (PBA), that may indicate the physicallocation of that logical sector of data in the memory. A logical sectorof data can be a number of bytes of data (e.g., 256 bytes, 512 bytes,1,024 bytes, or 4,096 bytes). However, embodiments are not limited tothese examples.

It is noted that other configurations for the physical blocks 107-0,107-1, . . . , 107-B, rows 103-0, 103-1, . . . , 103-R, sectors 105-0,105-1, . . . , 105-S, and pages are possible. For example, rows 103-0,103-1, . . . , 103-R of physical blocks 107-0, 107-1, . . . , 107-B caneach store data corresponding to a single logical sector which caninclude, for example, more or less than 512 bytes of data.

FIG. 2A illustrates an example of a pair of registers 214-1 and 214-2used to define a secure memory array in accordance with an embodiment ofthe present disclosure, and FIG. 2B illustrates a diagram of a portionof a memory array 201 that includes a secure memory array defined usingregisters 214-1 and 214-2 in accordance with an embodiment of thepresent disclosure. Although embodiments are not so limited, and one ormore registers and/or one or more pairs of registers could be used. Asshown in FIG. 2B, secure memory array 201 can include a number ofphysical blocks 207-0, 207-1, . . . , 207-B of memory cells, eachincluding a number of physical rows 203-0, 203-1, . . . , 203-R having anumber of sectors of memory cells, in a manner analogous to memory array101 described in connection with FIG. 1.

As shown in FIG. 2A, register 214-1 can define addresses of the securearray (e.g., the addresses of different portions of the secure array),and register 214-2 can define sizes of the secure array (e.g., the sizesof the different portions of the secure array). The addresses of thesecure array defined by register 214-1 can correspond to, for instance,starting points (e.g., starting LBAs) of the secure array (e.g., thestarting points of the different portions of the secure array), and thesizes of the secure array defined by register 214-2 can correspond to,for instance, ending points (e.g., ending LBAs) of the secure array(e.g., the ending points of the different portions of the secure array).

For example, as shown in FIG. 2A, registers 214-1 and 214-2 can define Npairs of values, with each respective pair comprising an address value(e.g., addr) defined by register 214-1 and a size value (e.g., size)defined by register 214-2. For instance, in the example illustrated inFIG. 2A, Pair₀ comprises address value addr₀ and size value size₀ (e.g.,Pair₀=[addr₀, size₀]), Pair₁ comprises address value addr₁ and sizevalue size₁ (e.g., Pair₁=[addr₁, size₁]), and so on, with Pair_(N)comprising address value addr_(N) and size value size_(N) (e.g.,Pair_(N)=[addr_(N), sizer]). The address value of a pair can correspondto a starting point (e.g., starting LBA) of a portion of the securearray, and the sum of the address value and the size value of that paircan correspond to the ending point (e.g., ending LBA) of that portion ofthe secure array. As such, the entire secure array (e.g., the portionsthat comprise the entire secure array) can be given by: [addr₀,addr₀+size₀]∪[addr₁, addr₁+size₁]∪ . . . ∪[addr_(N), addr_(N)+size_(N)].

The first pair whose size value defined by register 214-2 is zero canstop the definition of the secure array. For instance, in the exampleillustrated in FIG. 2A, if the size value of Pair₂ is zero, then thesecure array would be given by: [addr₀, addr₀+size₀]∪[addr₁,addr₁+size₁].

An example of a secure array defined by registers 214-1 and 214-2 (e.g.,with all size values defined by register 214-2 as non-zero) isillustrated in FIG. 2B. For instance, as shown in FIG. 2B, the address(e.g., LBA) associated with sector 205-0 of memory array 201 is addr₀,the address associated with sector 205-1 of memory array 201 isaddr₀+size₀, the address associated with sector 205-2 of memory array201 is addr₁, the address associated with sector 205-3 of memory array201 is addr₁+size₁, the address associated with sector 205-4 of memoryarray 201 is addr_(N), and the address associated with sector 205-5 ofmemory array 201 is addr_(N)+size_(N). As such, the secure arraycomprises sectors (e.g., the data stored in sectors) 205-0 through205-1, sectors 205-2 through 205-3, and 205-4 through 205-5. However,the sectors of memory array 201 that are before sector 205-0, andsectors 205-1 through 205-2 of memory array 201, are not part of thesecure array (e.g., the secure array comprises a subset of array 201).

FIG. 3 is a block diagram of a computing system 300 including a host 302and an apparatus in the form of a memory device 306 in accordance withan embodiment of the present disclosure. As used herein, an “apparatus”can refer to, but is not limited to, any of a variety of structures orcombinations of structures, such as a circuit or circuitry, a die ordice, a module or modules, a device or devices, or a system or systems,for example. Further, in an embodiment, computing system 300 can includea number of memory devices analogous to memory device 306.

In the embodiment illustrated in FIG. 3, memory device 306 can include amemory 316 having a memory array 301. Memory array 301 can be analogousto memory array 101 described in connection with FIG. 1 and memory array201 described in connection with FIG. 2B. Further, in an embodiment,memory array 301 (e.g., a subset of array 301, or the whole array 301)can be a secure array (e.g., an area of memory 316 to be kept undercontrol).

FIG. 3 illustrates a pair of registers 314-1 and 314-2 althoughembodiments are not so limited, and one or more registers and/or one ormore pairs of registers could be used. Registers 314-1 and 314-2 can be,for instance, registers 214-1 and 214-2, described in connection withFIG. 2A, and secure memory array 301 can be, for instance, memory array201 described in connection with FIG. 2B. Data (e.g., the data 333)stored in memory array 301 can include sensitive (e.g., non-user) data,such as device firmware and/or code to be executed for sensitiveapplications (e.g., the routine). In some examples, the memory device306 can include ECC corresponding to data 333 where the ECC, and/or adigest of data calculated by the memory device 306 are stored by thememory 316 in the same manner as the data 333 illustrated by FIG. 3(this embodiment is discussed in connection with FIG. 4).

In such embodiments, the pair of non-volatile registers 314-1, and 314-2can be used to define the secure array to store the data 333 (and/or theECC, corresponding data, and/or a digest). For example, in theembodiment illustrated in FIG. 3, circuitry 310 includes registers 314-1and 314-2 that can be used to define the secure array. For instance,register 314-1 can define the address (e.g., the starting LBA of thedata) of the secure array, and register 314-2 can define the size (e.g.,the ending LBA of the data) of the secure array. Using this method, thedata 333 can be stored and protected by the memory device 306.

As illustrated in FIG. 3, host 302 can be coupled to the memory device306 via interface 304. Host 302 and memory device 306 can communicate(e.g., send commands and/or data) on interface 304. Host 302 and/ormemory device 306 can be, or be part of, a computing device, a laptopcomputer, personal computer, digital camera, digital recording andplayback device, mobile telephone, PDA, memory card reader, interfacehub, or Internet of Things (IoT) enabled device, such as, for instance,an automotive (e.g., vehicular and/or transportation infrastructure) IoTenabled device or a medical (e.g., implantable and/or health monitoring)IoT enabled device, an automatic teller machine (ATM), among other hostsystems, and can include a memory access device (e.g., a processor). Oneof ordinary skill in the art will appreciate that “a processor” canintend one or more processors, such as a parallel processing system, anumber of coprocessors, etc.

Interface 304 can be in the form of a standardized physical interface.For example, when memory device 306 is used for information storage incomputing system 300, interface 304 can be a serial advanced technologyattachment (SATA) physical interface, a peripheral componentinterconnect express (PCIe) physical interface, a universal serial bus(USB) physical interface, or a small computer system interface (SCSI),among other physical connectors and/or interfaces. In general, however,interface 304 can provide an interface for passing control, address,information (e.g., data), and other signals between memory device 306and a host (e.g., host 302) having compatible receptors for interface304.

Memory device 306 includes controller 308 to communicate with host 302and with memory 316 (e.g., memory array 301). For instance, controller308 can send commands to perform operations on memory array 301,including operations to sense (e.g., read), program (e.g., write), move,and/or erase data, among other operations.

Controller 308 can be included on the same physical device (e.g., thesame die) as memory 316. Alternatively, controller 308 can be includedon a separate physical device that is communicatively coupled to thephysical device that includes memory 316. In an embodiment, componentsof controller 308 can be spread across multiple physical devices (e.g.,some components on the same die as the memory, and some components on adifferent die, module, or board) as a distributed controller.

Host 302 can include a host controller 321 to communicate with memorydevice 306. The host controller 321 can be included on the same physicalhost device 302. Alternatively, the host controller 321 can be aseparate physical device that is communicatively coupled to the memorydevice 306 and or multiple memory devices (discussed further inconnection with FIG. 4). The host controller 321 can send commands tomemory device 306 via interface 304. The host controller 321 cancommunicate with memory device 306 and/or the controller 308 on thememory device 306 to read, write, and/or erase data, among otheroperations. Further, in an embodiment, host 302 can be an IoT enableddevice, as described herein, having IoT communication capabilities.

Controller 308 on memory device 306 and/or the host controller 321 onhost 302 can include control circuitry and/or logic (e.g., hardware andfirmware). In an embodiment, controller 308 on memory device 306 and/orthe host controller 321 can be an application specific integratedcircuit (ASIC) coupled to a printed circuit board including a physicalinterface. Also, memory device 306, host controller 321 and/or host 302can include a buffer of volatile and/or non-volatile memory and a numberof registers (e.g., the registers 314-1 and 314-2).

For example, as shown in FIG. 3, memory device 306 can include circuitry310. In the embodiment illustrated in FIG. 3, circuitry 310 is includedin controller 308. However, embodiments of the present disclosure arenot so limited. For instance, in an embodiment, circuitry 310 may beincluded in (e.g., on the same die as) memory 316 (e.g., instead of incontroller 308). Circuitry 310 can comprise, for instance, hardware,firmware, and/or software.

Computing system 300 (e.g., host 302 and memory device 306) can utilizeerror identification in executed code to determine if an error has beenidentified in data 333. For example, the circuitry 310 may read data 333stored in the array 301 of the memory 316. The circuitry 310 canidentify a different memory which can include an ECC corresponding tothe data 333 read by the circuitry 310. As mentioned, the automaticcorrection of error introduced to the data 333 may introduce additionalerror. The memory device 306 may execute an integrity check to comparethe ECC to the data 333 read by the memory device 306. The memory device306 may take an action in response to the comparison of the read data ofthe memory 316 and the ECC, where the comparison indicates that the ECCidentified an error in the data 333 read by the memory 316. In this way,the memory device 306, the host controller 321, and/or the host 302 canmake a determination of how to correct the error identified by the ECC.

For example, the circuitry 310 can be configured to determine whetherthe error identified by the ECC affects an operation of the host device302 associated with the data 333 read by the memory 316. For example,the data 333 can be code for a routine relating to a powertrainoperation for a host 302 in the form of a vehicle. The powertrainroutine can be provisioned to the memory 316 as data 333 and to adifferent memory as ECC during manufacture and/or another secureinstance. The memory device 306 may be a boot memory device thatexecutes the powertrain routine (e.g., the data 333).

The host controller 321, the circuitry 310 and/or the memory 316 canexecute an integrity check in response to a start-up process of thememory 316 and/or other indication to execute the data 333. Theintegrity check can include a comparison by the host controller 321, thecircuitry 310 and/or the memory 316, of ECC read by a different memoryincluded on a different memory device in parallel to the data 333 readby the memory 316. The integrity check can include a determination bythe circuitry 310 and/or the host 302 that a correction applied to anerror identified by the ECC introduced an additional error to the ECC.Said differently, the automatic correction of identified error by theECC may have introduced new error to the ECC and applying a similarcorrection to the data 333 may introduce additional error the data 333.Introduction of other error may cause the routine to be skipped,altered, and/or other operational problems. Based on the integritycheck, the host 302, host controller 321, and/or the circuitry 310 canbe take an action to refrain from correcting the error corresponding tothe read data 333 of the memory in response to the error identified bythe ECC, and/or may determine an alternative method of correction.

FIG. 4 illustrates a block diagram of an example system 409 including ahost controller 421 and example memory devices 406-1 and 406-2 inaccordance with an embodiment of the present disclosure. A host (e.g.,the host 302 of FIG. 3) may include a host controller 421, where thehost controller 421 can be communicatively coupled to at least onememory device (e.g., memory device 406-1) and at least one other memorydevice (e.g., the memory device 406-2). For example, the system 409illustrated in FIG. 4 includes a host controller 421 communicativelycoupled via interface 404-1 to a memory device 406-1 having a memory416-1 and an array 401-1. The host controller 421 is illustrated ascommunicatively coupled via interface 404-2 to another memory device406-2 having a memory 416-2 and an array 401-2.

The memory device 406-1 can be provisioned with data 433-1, 433-2, and433-N (e.g., data 333 of FIG. 3). The data 433-1, 433-2, and 433-N canbe a code stream corresponding to a routine. The data 433-1, 433-2, and433-N coding for the routine may be securely provisioned onto the memorydevice 406-1 using a public/private key exchange between the hostassociated with the host controller 421 and the memory device 406-1. TheECC 432-1, 432-2, and 432-M may correspond to the data 433-1, 433-2, and433-N and be securely provisioned onto the memory device 406-2 using apublic/private key exchange between the host associated with the hostcontroller 421 and the memory device 406-1. The generation andvalidation of the public and private keys are discussed further inconnection with FIGS. 6-11.

In some examples, the data 433-1, 433-2, and 433-N making up the codestream for the routine can be fixed units of data (e.g., 5-8 doublewords, but examples are not so limited). The routine can be run-timeexecutable code which may be important to the operation of the hostcorresponding to the host controller 421. To detect error in the data433-1, 433-2, 433-N and determine an action to correct the error, thehost controller 421 can be associated with a different memory device406-2, where the different memory device 406-2 is provisioned with theroutine (e.g., a code stream for the routine coded in data 433-1, 433-2,and 433-N) and error correction/detection capabilities.

For example, the memory device 406-2 can include ECC 432-1, 432-2, 432-Mcorresponding to the routine, and/or digest 435-1, 435-2, 435-Pcorresponding to the routine. The ECC 432-1, 432-2, 432-M may includecode corresponding to data 433-1, 433-2, and 433-N of the memory device406-1 where the ECC is a bit parity concatenated therewith. For example,ECC 432-1 may include the code of data 433-1 concatenated with an errorcorrecting portion, ECC 432-2 may include the code of data 433-2concatenated with an error correcting portion, and ECC 432-M may includethe code of data 433-N concatenated with an error correcting portion.

The digests 435-1, 435-2, and 435-P are products of a hash functionapplied by the circuitry (e.g., the circuitry 310 of FIG. 3) to the code(e.g., the data 433-1, 433-2, 433-N) for the routine. For example, thedigest 435-1, 435-2, and 435-P can be cryptographic primitives (e.g., ahash) produced from corresponding data (e.g., the data 433-1, 433-2,433-N), where a change to the data can produce a different digest. Saiddifferently, a digest calculated by the circuitry of data 433-1 will bechange when an error is present in the data 433-1.

For example, the digest 435-1 can be a hash for the data 433-1, thedigest 435-2 can be a hash for the data 433-2, and the digest 435-P canbe a hash for the data 433-N. Used individually or together, the ECC(432-1, 432-2, 432-M) and the digests (435-1, 435-2, 435-P) can be usedby the host (e.g., the host 302 of FIG. 3), the host controller 421,and/or circuitry (e.g., the circuitry 310 of FIG. 3) to determine theintegrity of the code of the routine (e.g., the data 433-1, 433-2, and433-N) as it is executed by the memory device 406-1.

The data 433-1, 433-2, 433-N may be executed in parallel with the ECC432-1, 432-2, 432-M and/or the digest 435-1, 435-2, 435-P to identifyerror in the executed code (e.g., the data 433-1, 433-2, 433-N).Specifically, the memory device 406-2 can include circuitry (e.g., thecircuitry 310 of FIG. 3) configured to read ECC (e.g., 432-1, 432-2, and432-M) stored in an array 401-2 of the memory 416-2, and identify adifferent memory device 406-1 having read data 433-1, 433-2, 433-Ncorresponding to the ECC e.g., 432-1, 432-2, and 432-M of the memory416-2. The circuitry of the memory device 406-2, and/or the hostcontroller 421 can execute an integrity check to compare the ECC e.g.,432-1, 432-2, and 432-M to the read data 433-1, 433-2, and 433-N of thedifferent memory device 406-1. The integrity check can determine and/ormonitor the read data 433-1, 433-2, and 433-N for error, based on thecomparison to the ECC 432-1, 432-2, and 432-M.

In response to the comparison of the read data 433-1, 433-2, 433-N andthe ECC 432-1, 432-2, and 432-M, the host controller 421 and/or thecircuitry can take an action, where the comparison indicates that theECC identified an error in the read data 433-1, 433-2, and/or 433-N ofthe memory device 406-1. Because the correction of error can introducenew error into the data to be executed, the host controller 421 and/orthe circuitry associated with the memory device 406-1 may take an actionto refrain from correcting the error identified by the ECC 432-1, 432-2,and 432-M. Alternatively and/or additionally, the host controller 421and/or the circuitry associated with the memory device 406-1 candetermine how the error and/or the correction of the error may affectthe routine coded by the data 433-1, 433-2, and 433-N and determine tocorrect the error identified by the comparison of the ECC 432-1, 432-2,and 432-M and the data 433-1, 433-2, 433-N. In this way, inadvertenterror introduced by a corrective action can be monitored and/oridentified.

FIG. 5 illustrates an example flow diagram for error identification inexecuted code in accordance with embodiments of the present disclosure.At 522, a host device (e.g., the host 302 of FIG. 3) can set-up at leastone memory device to execute a routine for an operation of the hostdevice. For example, at 541, the host device can define a routine. Thehost device may securely communicate with one or more memory devices(e.g., the memory devices 406-1 and 406-2 of FIG. 4) by exchangingpublic/private keys to exchange encrypted data (e.g., the data 433-1,433-2, 433-N) to code for the routine. The host device and/or circuitry(e.g., the circuitry 310 of FIG. 3) associated with the memory devicescan provision at least one memory device with ECC (e.g., the ECC 432-1,432-2, 432-M) and/or may calculate a digest (e.g., 435-1, 435-2, and435-P of FIG. 4) based on the ECC and/or data.

As mentioned, the host device may be a vehicle and the host controllermay be included in the vehicle or external to the vehicle. The hostcontroller may be in communication with multiple memory devices, thememory devices may store data strings that code for important routines(e.g., powertrain operation) of the vehicle (e.g., the host device). Thememory devices may be provisioned with the data and corresponding ECCand/or the digests may be calculated at a secure location and/or asecure time. For example, the memory devices may be provisioned with thedata, ECC, and digest during the manufacture of the host and/or hostcontroller.

The host device may include a host controller (e.g., the host controller421 of FIG. 4) communicatively coupled to the memory devices to identifyerror in executed code. At 542, the host controller, and/or thecircuitry of the respective memory devices can execute the data streamand corresponding ECC in parallel. For example, a first memory devicemay be a boot memory device having memory and circuitry and incommunication with the host controller. A second memory device may be anerror correcting memory device having memory and circuitry, and also incommunication with the host controller. A system (e.g., the system 409of FIG. 4) may start-up and the first memory device may read the datastream of the routine in parallel with the second memory device readingthe ECC corresponding to the routine. The first memory device, viacircuitry (e.g., the circuitry 310 of FIG. 3), may transmit the readdata to the host controller. The second memory device, via circuitry(e.g., the circuitry 310 of FIG. 3), may transmit the read ECC to thehost controller.

At 543, the host controller may receive the executed (e.g., read) datatransmitted from circuitry of the first memory device and the ECCcorresponding to the data from the circuitry of the second memorydevice. In some examples, the circuitry of the second memory device maybe configured to transmit a calculated digest (e.g., a calculated hash)corresponding to the data stream transmitted by the first memory device.The digest may be transmitted by the circuitry of the second memorydevice individually or together with the ECC data such that the hostdevice may execute an integrity check.

For example, at 544, the host controller may execute an integrity checkby comparing the received ECC and/or the digest corresponding to thedata (and calculated by the circuitry of the second memory device) tothe read data from the first memory device. If the ECC of the secondmemory device and the read data of the first memory device do not match(“NO” at 545), there may be an error in the read data. Put another way,the ECC may automatically correct one or more errors thereby no longercorresponding to the data of the first memory device. In this example,at 547, the host controller and/or the circuitry associated with thefirst memory device may take an action in response to the comparisonthat the ECC identified an error in the read data of the first memorydevice.

In some examples, comparing the read data of the first memory device tothe ECC provided by the second memory device includes comparing a hashfunction corresponding to the data and a digest corresponding to theECC. The digest calculated may not match the expected read data (e.g.,or a hash of the expected read data) of the first memory device. Eachdigest (e.g., 435-1, 435-2, 435-P of FIG. 4) may be calculated based onthe data (e.g., 433-1, 433-2, 433-N of FIG. 4), where any change to thedata may change the value of the digest. When an error has occurred inthe data, the digest outputted by the second memory device may changeindicating an error. The host controller and/or the circuitry of thefirst memory device may compare, at 544, the received digest to the readdata. If the digest and the read data do not match, (e.g., “NO” at 546)an error has occurred and the host controller and/or the circuitry ofthe memory devices may take an action at 547.

For example, the circuitry of the first and/or second memory device candetermine where the error occurred in the routine and determine whateffect the error may have on the routine. The circuitry of the firstand/or second memory device can abort (e.g., halt) the operation of thehost device based on the identification of the error by the ECC and/orthe digest. Alternatively, and/or additionally, the host controller maycorrect the error in the read data based on the identification by theECC and/or the digest. In another example, the action taken may be analert indicating the error, where the alert is created by the circuitryof the first memory device and/or the second memory device andcommunicated to the host device.

During the during the integrity check comparison at 544, the hostcontroller, and/or the circuitry of the first memory device and/or thesecond memory device may determine that the received read data from thefirst memory device and the ECC and/or the digest of the second memorydevice match (“YES” at 548). The matching read data to the ECC and/orthe digest indicates that there is no error present in the read datafrom the first memory device. In this example, at 549, the circuitry ofthe first and/or the second memory device may proceed with the operationof the routine coded by the data.

FIG. 6 is a block diagram of an example system including a memory device606 and a host 602 in accordance with an embodiment of the presentdisclosure. Memory device 606 and host 602 can be, for example, host 302and memory device 306, respectively, described in connection with FIG.3.

A computing device can boot in stages using layers, with each layerauthenticating and loading a subsequent layer and providing increasinglysophisticated runtime services at each layer. A layer can be served by aprior layer and serve a subsequent layer, thereby creating aninterconnected web of the layers that builds upon lower layers andserves higher order layers. As is illustrated in FIG. 6, Layer 0 (“L₀”)651 and Layer 1 (“L₁”) 653 are within the memory device 606. Layer 0 651can provide a Firmware Derivative Secret (FDS) key 652 to Layer 1 653.The FDS key 652 can describe the identity of code of Layer 1 653 andother security relevant data. In an example, a particular protocol (suchas robust internet of things (RIOT) core protocol) can use the FDS 652to validate code of Layer 1 653 that it loads. In an example, theparticular protocol can include a device identification compositionengine (DICE) and/or the RIOT core protocol. As an example, an FDS caninclude Layer 1 firmware image itself, a manifest that cryptographicallyidentifies authorized Layer 1 firmware, a firmware version number ofsigned firmware in the context of a secure boot implementation, and/orsecurity-critical configuration settings for the device. A device secret658 can be used to create the FDS 652 and be stored in memory associatedwith the memory device 606.

The memory device can transmit data, as illustrated by arrow 654, to thehost 602. The transmitted data can include an external identificationthat is public, a certificate (e.g., an external identificationcertificate), and/or an external public key. Layer 2 (“L₂”) 655 of thehost 602 can receive the transmitted data, and execute the data inoperations of the operating system (“OS”) 657 and on a first application659-1 and a second application 659-2.

In an example operation, the memory device 606 can read the devicesecret 658, hash an identity of Layer 1 653, and perform a calculationincluding:K _(L1)=KDF[Fs(s),Hash(“immutable information”)]where K_(L1) is an external public key, KDF (e.g., KDF defined in theNational Institute of Standards and Technology (NIST) SpecialPublication 800-108) is a key derivation function (e.g., HMAC-SHA256),and Fs(s) is the device secret 658. FDS 652 can be determined byperforming:FDS=HMAC-SHA256[Fs(s),SHA256(“immutable information”)]Likewise, the host 602 can transmit data, as illustrated by arrow 656,to the memory device 606.

FIG. 7 is a block diagram of an example process to determine a number ofparameters in accordance with an embodiment of the present disclosure.FIG. 7 is an example of a determination of the parameters including theexternal public identification, the external certificate, and theexternal public key that are then sent, indicated by arrow 754, to Layer2 (e.g., Layer 2 655) of a host device (e.g., 602 in FIG. 6). Layer 0(“L₀”) 751 in FIG. 7 corresponds to Layer 0 651 in FIG. 6 and likewiseFDS 752 corresponds to FDS 652, Layer 1 753 corresponds to Layer 1 653,and arrows 754 and 756 correspond to arrows 654 and 656, respectively.

The FDS 752 from Layer 0 751 is sent to Layer 1 753 and used by anasymmetric ID generator 761 to generate a public identification(“ID_(lk public)”) 765 and a private identification 767. In theabbreviated “ID_(lk public),” the “lk” indicates Layer k (in thisexample Layer 1), and the “public” indicates that the identification isopenly shared. The public identification 765 is illustrated as shared bythe arrow extending to the right and outside of Layer 1 753 of thememory device. The generated private identification 767 is used as a keyinput into an encryptor 773. The encryptor 773 can be any processor,computing device, etc. used to encrypt data.

Layer 1 753 of a memory device can include an asymmetric key generator763. In at least one example, a random number generator (RND) 736 canoptionally input a random number into the asymmetric key generator 763.The asymmetric key generator 763 can generate a public key(“K_(Lk public)”) 769 (referred to as an external public key) and aprivate key (“K_(LK private)”) 771 (referred to as an external privatekey) associated with a memory device such as memory device 606 in FIG.6. The external public key 769 can be an input (as “data”) into theencryptor 773. The encryptor 773 can generate a result K′775 using theinputs of the external private identification 767 and the externalpublic key 769. The external private key 771 and the result K′775 can beinput into an additional encryptor 777, resulting in output K″ 779. Theoutput K″ 779 is the external certificate (“ID_(L1) certificate”) 781transmitted to the Layer 2 (655 of FIG. 6). The external certificate 781can provide an ability to verify and/or authenticate an origin of datasent from a device. As an example, data sent from the memory device canbe associated with an identity of the memory device by verifying thecertificate, as will be described further in association with FIG. 9.Further, the external public key (“K_(L1 public key)”) 783 can betransmitted to Layer 2. Therefore, the public identification 765, thecertificate 781, and the external public key 783 of a memory device canbe transmitted to Layer 2 of a host device.

FIG. 8 is a block diagram of an example process to determine a number ofparameters in accordance with an embodiment of the present disclosure.FIG. 8 illustrates a Layer 2 855 of a host (e.g., host 602 in FIG. 6)generating a device identification (“ID_(L2) public”) 866, a devicecertificate (“ID_(L2) Certificate”) 882, and a device public key(“K_(L2 public key)”) 884.

The external public key (“K_(L1 public key)”) 883 transmitted from Layer1 of the memory device to Layer 2 855 of a host, as described in FIG. 7,is used by an asymmetric ID generator 862 of the host to generate apublic identification (“ID_(lk public)”) 866 and a privateidentification 868 of the host. In the abbreviated “ID_(lk public),” the“lk” indicates Layer k (in this example Layer 2), and the “public”indicates that the identification is openly shared. The publicidentification 866 is illustrated as shared by the arrow extending tothe right and outside Layer 2 855. The generated private identification868 is used as a key input into an encryptor 874.

As shown in FIG. 8, the external certificate 881 and externalidentification 865, along with the external public key 883, are used bya certificate verifier 824. The certificate verifier 824 can verify theexternal certificate 881 received from a memory device (e.g., memorydevice 606), and determine, in response to the external certificate 881being verified or not being verified, whether to accept or discard datareceived from the memory device. Further details of verifying theexternal certificate 881 is described in connection with FIG. 9.

Layer 2 855 of the host can include an asymmetric key generator 864. Inat least one example, a random number generator (RND) 838 can optionallyinput a random number into the asymmetric key generator 864. Theasymmetric key generator 864 can generate a public key (“K_(Lk public)”)870 (referred to as a device public key) and a private key(“K_(LK private)”) 872 (referred to as a device private key) associatedwith a host device such as host 602 in FIG. 6. The device public key 870can be an input (as “data”) into the encryptor 874. The encryptor 874can generate a result K′ 876 using the inputs of the device privateidentification 868 and the device public key 870. The device private key872 and the result K′ 876 can be input into an additional encryptor 878,resulting in output K″ 880. The output K″ 880 is the device certificate(“ID_(L2) certificate”) 882 transmitted back to the Layer 1 (653 of FIG.6). The device certificate 882 can provide an ability to verify and/orauthenticate an origin of data sent from a device. As an example, datasent from the host can be associated with an identity of the host byverifying the certificate, as will be described further in associationwith FIG. 9. Further, the device public key (“K_(L2 public key)”) 884can be transmitted to Layer 1. Therefore, the public identification 866,the certificate 882, and the device public key 884 of the host can betransmitted to Layer 1 of a memory device.

In an example, in response to a memory device receiving a public keyfrom a host, the memory device can encrypt data to be sent to the hostusing the device public key. Vice versa, the host can encrypt data to besent to the memory device using the external public key. In response tothe host receiving data encrypted using the device public key, the hostcan decrypt the data using its own device private key. Likewise, inresponse to the memory device receiving data encrypted using theexternal public key, the memory device can decrypt the data using itsown external private key. As the device private key is not shared withanother device outside the host and the external private key is notshared with another device outside the memory device, the data sent tothe host and the memory device remains secure.

FIG. 9 is a block diagram of an example process to verify a certificatein accordance with an embodiment of the present disclosure. In theillustrated example of FIG. 9, a public key 983, a certificate 981, anda public identification 965 is provided from a memory device (e.g., fromLayer 1 653 of memory device 606 in FIG. 6). The data of the certificate981 and the external public key 983 can be used as inputs into adecryptor 985. The decryptor 985 can be any processor, computing device,etc used to decrypt data. The result of the decryption of thecertificate 981 and the external public key 983 can be used as an inputinto a secondary decryptor 987 along with the public identification,result in an output. The external public key 983 and the output from thedecryptor 987 can indicate, as illustrated at 989, whether thecertificate is verified by a comparison, resulting in a yes or no 991 asan output. In response to the certificate being verified, data receivedfrom the device being verified can be accepted, decrypted, andprocessed. In response to the certificate not being verified, datareceived from the device being verified can be discarded, removed,and/or ignored. In this way, nefarious devices sending nefarious datacan be detected and avoided. As an example, a hacker sending data to beprocessed can be identified and the hacking data not processed.

FIG. 10 is a block diagram of an example process to verify a signaturein accordance with an embodiment of the present disclosure. In theinstance where a device is sending data that may be verified in order toavoid subsequent repudiation, a signature can be generated and sent withdata. As an example, a first device may make a request of a seconddevice and once the second device performs the request, the first devicemay indicate that the first device never made such a request. Ananti-repudiation approach, such as using a signature, can avoidrepudiation by the first device and insure that the second device canperform the requested task without subsequent difficulty.

A memory device 1006 (such as memory device 306 in FIG. 3) can send data1090 to a host (such as host 302 in FIG. 3). The memory device 1006 cangenerate, at 1094, a signature 1096 using a device private key 1071. Thesignature 1096 can be transmitted to the host 1002. The host 1002 canverify, at 1098, the signature using data 1092 and the external publickey 1069 previously received. In this way, the signature is generatedusing a private key and verified using a public key. In this way, theprivate key used to generate a unique signature can remain private tothe device sending the signature while allowing the receiving device tobe able to decrypt the signature using the public key of the sendingdevice for verification. This is in contrast to encryption/decryption ofthe data, which is encrypted by the sending device using the public keyof the receiving device and decrypted by the receiving device using theprivate key of the receiver. In at least one example, the device canverify the digital signature by using an internal cryptography process(e.g., Elliptical Curve Digital signature (ECDSA) or a similar process.

FIG. 11 is a block diagram of an example memory device 1106 inaccordance with an embodiment of the present disclosure. Memory device1106 can be, for example, memory device 306 previously described inconnection with FIG. 3.

As shown in FIG. 11, memory device 1106 can include a number of memoryarrays 1101-1 through 1101-7. Memory arrays 1101-1 through 1101-7 can beanalogous to memory array 101 previously described in connection withFIG. 1. Further, in the example illustrated in FIG. 11, memory array1101-3 is a secure array, subset 1111 of memory array 1101-6 comprises asecure array, and subsets 1113 and 1115 of memory array 1101-7 comprisea secure array. Subsets 1111, 1113, and 1115 can each include, forinstance, 4 kilobytes of data. However, embodiments of the presentdisclosure are not limited to a particular number or arrangement ofmemory arrays or secure arrays.

As shown in FIG. 11, memory device 1106 can include a remediation (e.g.,recovery) block 1117. Remediation block 1117 can be used as a source ofdata in case of errors (e.g., mismatches) that may occur duringoperation of memory device 1106. Remediation block 1117 may be outsideof the area of memory device 1106 that is addressable by a host.

As shown in FIG. 11, memory device 1106 can include a serial peripheralinterface (SPI) 1104 and a controller 1108. Memory device 1106 can useSPI 1104 and controller 1108 to communicate with a host and memoryarrays 1101-1 through 1101-7, as previously described herein (e.g., inconnection with FIG. 3).

As shown in FIG. 11, memory device 1106 can include a secure register1119 for managing the security of memory device 1106. For example,secure register 1119 can configure, and communicate externally, to anapplication controller. Further, secure register 1119 may be modifiableby an authentication command.

As shown in FIG. 11, memory device 1106 can include keys 1121. Forinstance, memory device 1106 can include eight different slots to storekeys such as root keys, DICE-RIOT keys, and/or other external sessionkeys.

As shown in FIG. 11, memory device 1106 can include an electronicallyerasable programmable read-only memory (EEPROM) 1123. EEPROM 1123 canprovide a secure non-volatile area available for a host, in whichindividual bytes of data can be erased and programmed.

As shown in FIG. 11, memory device 1106 can include counters (e.g.,monotonic counters) 1125. Counters 1125 can be used as an anti-replaymechanism (e.g., freshness generator) for commands (e.g., to sign acommand set or sequence) received from and/or sent to a host. Forinstance, memory device 1106 can include six different monotoniccounters, two of which may be used by memory device 1106 for theauthenticated commands, and four of which may be used by the host.

As shown in FIG. 11, memory device 1106 can include an SHA-256cryptographic hash function 1127, and/or an HMAC-SHA256 cryptographichash function 1129. SHA-256 and/or HMAC-SHA256 cryptographic hashfunctions 1127 and 1129 can be used by memory device 1106 to generatecryptographic hashes, such as, for instance, the cryptographic hashes ofthe update 220 previously described herein in connection with FIG. 3,and/or a golden hash used to validate the data stored in memory arrays1101-1 through 1101-7 as previously described herein. Further, memorydevice 1106 can support L0 and L1 of DICE-RIOT 1131.

Although specific embodiments have been illustrated and describedherein, those of ordinary skill in the art will appreciate that anarrangement calculated to achieve the same results can be substitutedfor the specific embodiments shown. This disclosure is intended to coveradaptations or variations of a number of embodiments of the presentdisclosure. It is to be understood that the above description has beenmade in an illustrative fashion, and not a restrictive one. Combinationof the above embodiments, and other embodiments not specificallydescribed herein will be apparent to those of ordinary skill in the artupon reviewing the above description. The scope of a number ofembodiments of the present disclosure includes other applications inwhich the above structures and methods are used. Therefore, the scope ofa number of embodiments of the present disclosure should be determinedwith reference to the appended claims, along with the full range ofequivalents to which such claims are entitled.

In the foregoing Detailed Description, some features are groupedtogether in a single embodiment for the purpose of streamlining thedisclosure. This method of disclosure is not to be interpreted asreflecting an intention that the disclosed embodiments of the presentdisclosure have to use more features than are expressly recited in eachclaim. Rather, as the following claims reflect, inventive subject matterlies in less than all features of a single disclosed embodiment. Thus,the following claims are hereby incorporated into the DetailedDescription, with each claim standing on its own as a separateembodiment.

What is claimed is:
 1. An apparatus, comprising: a memory; and circuitryassociated with the memory, the circuitry configured to: read datastored in a secure array of the memory; identify a different memoryhaving an error correcting code (ECC) corresponding to the read data ofthe memory; execute an integrity check to compare the ECC to the readdata of the memory; and take an action in response to the comparison ofthe read data of the memory and the ECC, wherein: the comparisonindicates that the ECC identified an error in the read data of thememory; and wherein the memory refrains from applying a correction tothe read data of the memory, based on the error identified by the ECC ofthe different memory.
 2. The apparatus of claim 1, wherein the ECC isread by the different memory in parallel to the read data of the memory.3. The apparatus of claim 1, wherein the action taken is to refrain fromcorrecting the error in the read data of the memory in response to theerror identified by the ECC.
 4. The apparatus of claim 1, wherein theECC of the different memory and the read data of the memory areassociated with a powertrain operation of a host device associated withthe memory and the different memory.
 5. The apparatus of claim 4,wherein the circuitry is further configured to: generate an alert inresponse to the indication that the ECC identified the error in the readdata of the memory; and transmit the alert to the host device associatedwith the memory and the different memory.
 6. An apparatus, comprising: amemory; and circuitry associated with the memory, the circuitryconfigured to: read error correcting code (ECC) stored in a secure arrayof the memory; identify a different memory having read datacorresponding to the ECC of the memory, wherein the read data of thedifferent memory and the ECC of the memory are read at a start-up of thememory and the different memory; execute an integrity check to comparethe ECC to the read data of the different memory; and take an action inresponse to the comparison of the read data of the different memory andthe ECC of the memory, wherein the comparison indicates that the ECCidentified an error in the read data of the different memory.
 7. Theapparatus of claim 6, wherein the memory includes the ECC to monitorerror introduced to the read data of the different memory when the datais read by the different memory.
 8. A system, comprising: a controller;a first memory device in communication with the controller; a secondmemory device in communication with the controller, the controllerconfigured to: receive read data from the first memory device; receivean error correcting code (ECC) corresponding to the read data of thefirst memory device; execute an integrity check by comparing the readdata of the first memory device and the ECC provided by the secondmemory device, wherein comparing the read data of the first memorydevice to the ECC provided by the second memory device includescomparing a hash function corresponding to the data and a digestcorresponding to the ECC; and take an action in response to thecomparison of the read data of the first memory device and the ECC,wherein the comparison indicates that the ECC identified an error in theread data of the first memory device.
 9. The system of claim 8, whereinthe controller is associated with a vehicle.
 10. The system of 9,wherein the read data of the first memory device is data associated witha powertrain operation of the vehicle.
 11. The system of claim 9,wherein operations of the vehicle are halted in response to the erroridentified by the ECC.
 12. The system of claim 8, wherein the erroridentified in the read data of the first memory device is corrected bythe controller.
 13. A method, comprising: receiving read data of a firstmemory device, wherein receiving the read data of the first memorydevice includes receiving instructions to execute a routine to operate apowertrain of a host vehicle; receiving an error correcting code (ECC)from a second memory device, wherein the ECC corresponds to the readdata of the first memory device; comparing the ECC from the secondmemory device to the read data of the first memory device to determineerror detected by the ECC; determining an integrity of the read data ofthe first memory based on the comparison of the ECC to the read data ofthe first memory; and taking an action in response to the determinedintegrity of the read data of the first memory.
 14. The method of claim13, wherein taking an action further comprises: generating, by the firstmemory device, an alert indicating an error in the read data of thefirst memory device and identified by the integrity check; andtransmitting to a controller in communication with the first memorydevice, the alert indicating the error identified.
 15. The method ofclaim 13, wherein taking an action further comprises: receiving, by acontroller included in the vehicle, an alert in response to an erroridentified by the determined integrity; and aborting, by the controller,the powertrain operations of the host vehicle.
 16. An apparatus,comprising: a memory; and circuitry associated with the memory, thecircuitry configured to: read data stored in a secure array of thememory; identify a different memory having an error correcting code(ECC) corresponding to the read data of the memory; execute an integritycheck to compare the ECC to the read data of the memory; take an actionin response to the comparison of the read data of the memory and theECC, wherein the comparison indicates that the ECC identified an errorin the read data of the memory; and determine that a correction appliedto the error identified by the ECC introduced an additional error to theECC.
 17. An apparatus, comprising: a memory; and circuitry associatedwith the memory, the circuitry configured to: read data stored in asecure array of the memory; identify a different memory having an errorcorrecting code (ECC) corresponding to the read data of the memory;execute an integrity check to compare the ECC to the read data of thememory, wherein the integrity check is executed by the memory inresponse to a start-up process of the memory; and take an action inresponse to the comparison of the read data of the memory and the ECC,wherein the comparison indicates that the ECC identified an error in theread data of the memory.
 18. An apparatus, comprising: a memory; andcircuitry associated with the memory, the circuitry configured to: readdata stored in a secure array of the memory; identify a different memoryhaving an error correcting code (ECC) corresponding to the read data ofthe memory execute an integrity check to compare the ECC to the readdata of the memory; take an action in response to the comparison of theread data of the memory and the ECC, wherein the comparison indicatesthat the ECC identified an error in the read data of the memory; anddetermine whether the error identified by the ECC affects an operationof a host device associated with the read data of the memory.
 19. Anapparatus, comprising: a memory; and circuitry associated with thememory, the circuitry configured to: read error correcting code (ECC)stored in a secure array of the memory; identify a different memoryhaving read data corresponding to the ECC of the memory, wherein: thememory and the different memory are associated with a host; and the readdata is written to the different memory and the ECC is written to thememory when the host is manufactured; execute an integrity check tocompare the ECC to the read data of the different memory; and take anaction in response to the comparison of the read data of the differentmemory and the ECC of the memory, wherein the comparison indicates thatthe ECC identified an error in the read data of the different memory.